// pages/booking/foster-care-detail/index.js
const apiService = require('../../../utils/api.js');
const app = getApp();
Page({

	/**
	 * 页面的初始数据
	 */
	data: {
		statusBarHeight: 44, // 系统状态栏高度
		
		// 导航栏相关
		scrollY: 0,
		navbarOpacity: 0,  // 导航栏背景透明度 (0-1)
		navbarTextColor: '#333333', // 导航栏文字颜色
		
		// 门店信息
		storeInfo: {
			name: '',
			address: '',
			_id: '',
			storeId: null
		},
		// 宠物列表
		petList: [],
		selectedPetId: '', // 选中的宠物ID
		// 房型
		roomType: '大单间',
		roomUnit: '天', // 房间收费单位：'天' 或 '小时'
		// 寄养时间
		checkInDate: '',
		checkInTime: '9:00入住',
		checkOutDate: '',
		checkOutTime: '18:00结束',
		totalDays: 0,
		// 联系人信息
		contactName: '',
		contactPhone: '',
		remarks: '',
		// 输入验证状态
		isValidContactName: true,
		isValidPhone: true,
		// 协议勾选
		agreementChecked: false,
		// 价格信息
		totalPrice: 0,
		pricePerDay: 108,
		// 日期选择弹窗
		showDatePicker: false,
		// 表单完整性状态
		isFormComplete: false
	},

	/**
	 * 生命周期函数--监听页面加载
	 */
	onLoad(options) {
		// 获取系统信息
		this.getSystemInfo();
		
		// 处理页面参数
		this.processPageOptions(options);
		
		// 加载宠物列表
		this.loadPetList();
		
		// 恢复表单数据（在加载完参数后）
		this.restoreFormData();
		
		// 计算总天数
		this.calculateTotalDays();
		
		// 计算价格
		this.calculatePrice();
	},

	/**
	 * 生命周期函数--监听页面显示
	 */
	onShow() {
		// 检查是否有新的房型数据更新标记（从房型选择页面返回时）
		const roomUpdated = wx.getStorageSync('foster_room_updated');
		const roomUpdateData = wx.getStorageSync('foster_room_update_data');
		
		if (roomUpdated && roomUpdateData) {
			console.log('onShow - 检测到房型更新标记，更新房型数据:', roomUpdateData);
			
			// 清除更新标记，避免重复更新
			wx.removeStorageSync('foster_room_updated');
			wx.removeStorageSync('foster_room_update_data');
			
			// 更新房型信息
			const newRoomType = roomUpdateData.name || roomUpdateData.roomType || this.data.roomType;
			const newPricePerDay = roomUpdateData.price || this.data.pricePerDay;
			let newRoomUnit = '天';
			if (roomUpdateData.unit) {
				if (roomUpdateData.unit.includes('小时')) {
					newRoomUnit = '小时';
				} else if (roomUpdateData.unit.includes('天')) {
					newRoomUnit = '天';
				} else {
					newRoomUnit = roomUpdateData.unit;
				}
			}
			
			console.log('onShow - 更新房型:', { newRoomType, newPricePerDay, newRoomUnit });
			
			this.setData({
				roomType: newRoomType,
				pricePerDay: newPricePerDay,
				roomUnit: newRoomUnit
			}, () => {
				// 重新计算价格
				this.calculatePrice();
				// 保存到缓存
				this.saveFormData();
			});
		} else {
			// 检查URL参数中是否有房型数据（通过navigateTo跳转时）
			const pages = getCurrentPages();
			const currentPage = pages[pages.length - 1];
			const pageOptions = currentPage.options || {};
			
			if (pageOptions.roomData) {
				console.log('onShow - 从URL参数检测到房型数据');
				this.processPageOptions(pageOptions);
			} else {
				// 检查缓存中的房型数据是否与当前不同
				const cachedFormData = wx.getStorageSync('foster_care_form_data');
				if (cachedFormData && cachedFormData.roomType && cachedFormData.roomType !== this.data.roomType) {
					console.log('onShow - 从缓存检测到新房型数据:', cachedFormData.roomType);
					// 如果缓存中的房型与当前不同，说明房型已更新，需要同步
					this.setData({
						roomType: cachedFormData.roomType,
						pricePerDay: cachedFormData.pricePerDay || this.data.pricePerDay,
						roomUnit: cachedFormData.roomUnit || this.data.roomUnit
					}, () => {
						this.calculatePrice();
					});
				} else {
					// 如果没有新房型数据，恢复之前保存的表单数据（包括联系人等信息）
					this.restoreFormData(true); // 保留当前房型
					this.calculatePrice();
				}
			}
		}
	},

	/**
	 * 获取系统信息
	 */
	getSystemInfo() {
		const systemInfo = wx.getSystemInfoSync();
		this.setData({
			statusBarHeight: systemInfo.statusBarHeight || 44
		});
	},

	/**
	 * 处理页面参数
	 */
	processPageOptions(options) {
		// 处理传入的房型数据（优先使用传入的房型数据，覆盖缓存数据）
		if (options.roomData) {
			try {
				const roomData = JSON.parse(decodeURIComponent(options.roomData));
				console.log('收到房型数据:', roomData);
				
				const newRoomType = roomData.name || roomData.roomType || this.data.roomType;
				const newPricePerDay = roomData.price || this.data.pricePerDay;
				// 处理unit字段：如果是从房型选择页面传来的，unit可能是"/只/天"，需要提取出"天"
				let newRoomUnit = '天';
				if (roomData.unit) {
					if (roomData.unit.includes('小时')) {
						newRoomUnit = '小时';
					} else if (roomData.unit.includes('天')) {
						newRoomUnit = '天';
					} else {
						newRoomUnit = roomData.unit;
					}
				}
				
				console.log('处理房型数据，设置:', { 
					房型名称: newRoomType, 
					价格: newPricePerDay, 
					单位: newRoomUnit,
					来源数据: roomData
				});
				
				this.setData({ 
					roomType: newRoomType,
					pricePerDay: newPricePerDay,
					roomUnit: newRoomUnit
				});
				
				// 如果传递的房型数据中有有效的价格，直接使用，不需要从API重新查询
				// 如果价格无效或缺失，则从API同步价格以确保准确性
				if (!newPricePerDay || newPricePerDay <= 0 || newPricePerDay === this.data.pricePerDay) {
					// 价格未传递或不正确，从API同步（但使用精确匹配，避免误匹配）
					console.log('价格未传递或无效，从API同步价格，使用精确匹配');
					// 延迟执行，确保setData已完成
					setTimeout(() => {
						this.updateServicePricingFromStoreServices();
					}, 100);
				} else {
					// 重新计算价格（使用传递的价格）
					console.log('使用传递的价格:', newPricePerDay);
					this.calculatePrice();
				}
				
				// 更新缓存中的房型数据，同时保留其他已填写的信息
				const formData = wx.getStorageSync('foster_care_form_data') || {};
				formData.roomType = newRoomType;
				formData.pricePerDay = newPricePerDay;
				formData.roomUnit = newRoomUnit;
				formData.timestamp = Date.now();
				
				// 保留其他已填写的字段（如果不存在则保留原有的）
				if (!formData.selectedPetId && this.data.selectedPetId) formData.selectedPetId = this.data.selectedPetId;
				if (!formData.checkInDate && this.data.checkInDate) formData.checkInDate = this.data.checkInDate;
				if (!formData.checkInTime && this.data.checkInTime) formData.checkInTime = this.data.checkInTime;
				if (!formData.checkOutDate && this.data.checkOutDate) formData.checkOutDate = this.data.checkOutDate;
				if (!formData.checkOutTime && this.data.checkOutTime) formData.checkOutTime = this.data.checkOutTime;
				if (!formData.contactName && this.data.contactName) formData.contactName = this.data.contactName;
				if (!formData.contactPhone && this.data.contactPhone) formData.contactPhone = this.data.contactPhone;
				if (!formData.remarks && this.data.remarks) formData.remarks = this.data.remarks;
				if (typeof formData.agreementChecked !== 'boolean' && typeof this.data.agreementChecked === 'boolean') {
					formData.agreementChecked = this.data.agreementChecked;
				}
				if (!formData.storeInfo && this.data.storeInfo) formData.storeInfo = this.data.storeInfo;
				
				wx.setStorageSync('foster_care_form_data', formData);
				console.log('已更新缓存，保留所有表单数据');
			} catch (error) {
				console.error('解析房型数据失败:', error);
			}
		}
		
		// 处理传入的storeId，加载门店信息
		const storeManager = getApp().getStoreManager();
		if (options.storeId) {
			const storeId = options.storeId;
			storeManager.getStoreById(storeId).then(store => {
				if (store) {
					this.setData({
						storeInfo: {
							name: store.name,
							address: store.address,
							_id: store._id || '',
							storeId: store.storeId || store.id || null
						}
					});
				} else {
					// 回退到最近门店
					storeManager.getNearestStore().then(nearest => {
						if (nearest) {
							this.setData({
								storeInfo: {
									name: nearest.name,
									address: nearest.address,
									_id: nearest._id || '',
									storeId: nearest.storeId || nearest.id || null
								}
							});
						}
					});
				}
			}).catch(err => {
				console.warn('获取门店信息失败，使用默认门店:', err);
				// 回退到最近门店
				storeManager.getNearestStore().then(nearest => {
					if (nearest) {
						this.setData({
							storeInfo: {
								name: nearest.name,
								address: nearest.address,
								_id: nearest._id || '',
								storeId: nearest.storeId || nearest.id || null
							}
						});
					}
				});
			});
		} else {
			// 未传storeId，加载最近门店
			storeManager.getNearestStore().then(nearest => {
				if (nearest) {
					this.setData({
						storeInfo: {
							name: nearest.name,
							address: nearest.address,
							_id: nearest._id || '',
							storeId: nearest.storeId || nearest.id || null
						}
					});
				}
			});
		}
		
		// 处理传入的房型、日期等参数
		if (options.roomType) {
			this.setData({ roomType: options.roomType });
		}
		if (options.checkInDate && options.checkOutDate) {
			this.setData({
				checkInDate: options.checkInDate,
				checkOutDate: options.checkOutDate
			});
			this.calculateTotalDays();
		}
	},

	/**
	 * 加载宠物列表
	 * @param {boolean} forceRefresh 是否强制刷新缓存
	 */
	async loadPetList(forceRefresh = false) {
		console.log('=== loadPetList开始加载，强制刷新:', forceRefresh);
		try {
			// 使用DataManager获取宠物列表，保持缓存一致性
			const dataManager = app.getDataManager();
			const petData = await dataManager.getPetList(forceRefresh);
			
			console.log('DataManager返回结果:', petData);
			if (petData && Array.isArray(petData) && petData.length > 0) {
				const pets = petData.map(p => ({
					id: p._id || p.id,
					_id: p._id || p.id,
					name: p.name || p.nickName || '宠物',
					breed: p.breed || p.species || '',
					type: p.type || p.category || '',
					avatar: p.avatar || p.avatarUrl || ((/狗/.test(p.type || p.category || '') || (p.category === '狗狗') || (p.type === 'dog')) ? '/assets/common/img_dog_avatar_default.png' : '/assets/common/img_cat_avatar_default.png')
				}));
				console.log('处理后的宠物列表:', pets);
				this.setData({ petList: pets });
				console.log('宠物列表加载成功，数量:', pets.length, '强制刷新:', forceRefresh);
				console.log('setData完成，当前页面宠物列表长度:', this.data.petList.length);
			} else {
				console.log('DataManager返回数据为空，使用模拟数据');
				this.setData({ petList: this.getMockPetList() });
			}
		} catch (err) {
			console.warn('获取宠物列表失败，使用本地模拟:', err);
			this.setData({ petList: this.getMockPetList() });
		}
	},
	// 本地模拟宠物列表（用于降级）
	getMockPetList() {
		return [];
	},

	/**
	 * 计算总天数
	 * 寄养预约时间是从当天早上开始，截止当天晚上结束
	 * 例如：10-24到10-25应该是2天（10-24一天 + 10-25一天）
	 */
	calculateTotalDays() {
		const { checkInDate, checkOutDate } = this.data;
		if (checkInDate && checkOutDate) {
			// 创建只包含日期的Date对象，忽略时分秒
			const checkIn = new Date(checkInDate + 'T00:00:00');
			const checkOut = new Date(checkOutDate + 'T00:00:00');
			
			// 计算两个日期之间的天数差（自然日）
			const timeDiff = checkOut.getTime() - checkIn.getTime();
			const dayDiff = Math.floor(timeDiff / (1000 * 60 * 60 * 24));
			
			// 包含起始和结束日期，所以+1（10-24到10-25：1+1=2天）
			const totalDays = dayDiff + 1;
			
			this.setData({
				totalDays: totalDays > 0 ? totalDays : 1 // 至少1天
			});
		}
	},

	/**
	 * 计算价格
	 */
	calculatePrice() {
		const { totalDays, pricePerDay } = this.data;
		const totalPrice = totalDays * pricePerDay;
		this.setData({
			totalPrice: totalPrice
		});
	},

	/**
	 * 返回上一页
	 */
	onBack() {
		wx.navigateBack({
			delta: 1,
			success: () => {
				console.log('返回上一页成功');
			},
			fail: (error) => {
				console.error('返回上一页失败:', error);
				// 降级处理：跳转到首页
				wx.switchTab({
					url: '/pages/home/index/index'
				});
			}
		});
	},

	/**
	 * 选择宠物
	 */
	selectPet(e) {
		const { petId } = e.currentTarget.dataset;
		// 如果点击的是已选中的宠物，则取消选择
		if (this.data.selectedPetId === petId) {
			this.setData({
				selectedPetId: ''
			}, () => {
				this.checkFormComplete();
				// 数据更新后保存表单数据
				this.saveFormData();
			});
		} else {
			// 选中新宠物，并重新排序列表，将选中的宠物移到第一位
			const { petList } = this.data;
			const selectedPetIndex = petList.findIndex(pet => pet.id === petId);
			
			if (selectedPetIndex !== -1 && selectedPetIndex !== 0) {
				// 创建新的宠物列表，将选中的宠物移到第一位
				const selectedPet = petList[selectedPetIndex];
				const newPetList = [
					selectedPet,
					...petList.slice(0, selectedPetIndex),
					...petList.slice(selectedPetIndex + 1)
				];
				
				this.setData({
					selectedPetId: petId,
					petList: newPetList
				}, () => {
					this.checkFormComplete();
					// 数据更新后保存表单数据
					this.saveFormData();
				});
			} else {
				// 宠物已经在第一位或未找到，只更新选中状态
				this.setData({
					selectedPetId: petId
				}, () => {
					this.checkFormComplete();
					// 数据更新后保存表单数据
					this.saveFormData();
				});
			}
		}
	},

	/**
	 * 添加宠物 - 跳转到添加宠物页面
	 */
	addPet() {
		console.log('=== addPet方法被调用，即将跳转到添加宠物页面 ===');
		wx.navigateTo({
			url: `/pages/pet/add-pet/index?mode=add&from=foster-care-detail`,
			success: () => {
				console.log('跳转到添加宠物页面成功');
			},
			fail: (error) => {
				console.error('跳转到添加宠物页面失败：', error);
				wx.showToast({
					title: '跳转失败，请重试',
					icon: 'none'
				});
			}
		});
	},

	/**
	 * 刷新宠物列表 - 添加宠物成功后调用
	 */
	refreshPetList(newPetId) {
		console.log('=== refreshPetList方法被调用，刷新宠物列表 ===', newPetId);
		console.log('当前宠物列表长度:', this.data.petList.length);
		// 强制刷新缓存，重新获取宠物列表
		this.loadPetList(true);
		// 如果有新创建的宠物ID，延迟选择该宠物
		if (newPetId) {
			console.log('将在800ms后尝试选择新宠物:', newPetId);
			setTimeout(() => {
				console.log('延迟时间到，开始选择新宠物:', newPetId);
				this.selectNewPet(newPetId);
			}, 800); // 增加延迟时间，确保数据加载完成
		}
	},

	/**
	 * 选择新创建的宠物
	 */
	selectNewPet(petId) {
		console.log('=== selectNewPet方法被调用，选择宠物ID:', petId);
		const { petList } = this.data;
		console.log('当前宠物列表:', petList);
		
		const targetPet = petList.find(pet => {
			const match = pet._id === petId || pet.id === petId;
			console.log('检查宠物匹配:', { petId: pet._id || pet.id, targetId: petId, match });
			return match;
		});
		
		if (targetPet) {
			console.log('找到目标宠物，设置为选中状态:', targetPet);
			this.setData({
				selectedPetId: targetPet._id || targetPet.id
			});
			// 重新计算价格
			this.calculatePrice();
			console.log('宠物选择完成，当前选中ID:', targetPet._id || targetPet.id);
		} else {
			console.warn('未找到目标宠物:', petId, '当前宠物列表:', petList);
		}
	},

	/**
	 * 选择房型
	 */
	selectRoomType() {
		// 跳转前保存当前表单数据
		this.saveFormData();
		
		wx.navigateTo({
			url: '/pages/booking/foster-care/index',
			success: () => {
				console.log('跳转到房型选择页面成功');
			},
			fail: (error) => {
				console.error('跳转到房型选择页面失败：', error);
			}
		});
	},

	/**
	 * 选择时间
	 */
	selectTime() {
		// 显示日期选择弹窗
		this.setData({
			showDatePicker: true
		});
	},

	/**
	 * 联系人输入 - 限制为中文或英文字符
	 */
	onContactNameInput(e) {
		let value = e.detail.value;
		
		// 只允许中文、英文字母和空格
		value = value.replace(/[^a-zA-Z\u4e00-\u9fa5\s]/g, '');
		
		// 限制长度
		if (value.length > 10) {
			value = value.substring(0, 10);
		}
		
		// 验证格式
		const isValid = this.isValidContactName(value);
		
		this.setData({
			contactName: value,
			isValidContactName: isValid
		}, () => {
			this.checkFormComplete();
			// 数据更新后保存表单数据
			this.saveFormData();
		});
	},

	/**
	 * 联系电话输入 - 限制为手机号格式
	 */
	onContactPhoneInput(e) {
		let value = e.detail.value;
		
		// 只允许数字
		value = value.replace(/[^\d]/g, '');
		
		// 限制长度为11位
		if (value.length > 11) {
			value = value.substring(0, 11);
		}
		
		// 验证格式
		const isValid = this.isValidPhone(value);
		
		this.setData({
			contactPhone: value,
			isValidPhone: isValid
		}, () => {
			this.checkFormComplete();
			// 数据更新后保存表单数据
			this.saveFormData();
		});
	},

	/**
	 * 备注信息输入 - 可以为空，限制长度
	 */
	onRemarksInput(e) {
		let value = e.detail.value;
		
		// 限制长度为200字符
		if (value.length > 200) {
			value = value.substring(0, 200);
		}
		
		this.setData({
			remarks: value
		}, () => {
			// 数据更新后保存表单数据
			this.saveFormData();
		});
	},

	/**
	 * 协议勾选
	 */
	toggleAgreement() {
		this.setData({
			agreementChecked: !this.data.agreementChecked
		}, () => {
			this.checkFormComplete();
			// 数据更新后保存表单数据
			this.saveFormData();
		});
	},

	/**
	 * 查看协议
	 */
	viewAgreement() {
		wx.navigateTo({
			url: '/pages/home-sub/agreement/index?type=foster',
			success: () => {
				console.log('跳转到寄养协议页面成功');
			},
			fail: (error) => {
				console.error('跳转到寄养协议页面失败:', error);
				wx.showToast({
					title: '跳转失败，请重试',
					icon: 'none'
				});
			}
		});
	},

	/**
	 * 验证手机号格式
	 */
	isValidPhone(phone) {
		const phoneRegex = /^1[3-9]\d{9}$/;
		return phoneRegex.test(phone);
	},

	/**
	 * 验证联系人姓名格式
	 */
	isValidContactName(name) {
		// 不能为空，只能包含中文、英文字母和空格
		if (!name || name.trim().length === 0) return false;
		const nameRegex = /^[a-zA-Z\u4e00-\u9fa5\s]+$/;
		return nameRegex.test(name.trim());
	},

	/**
	 * 检查表单完整性
	 */
	checkFormComplete() {
		const { selectedPetId, roomType, checkInDate, checkOutDate, contactName, contactPhone, agreementChecked } = this.data;
		
		// 验证联系人姓名格式
		const isContactNameValid = this.isValidContactName(contactName);
		
		// 验证手机号格式
		const isPhoneValid = this.isValidPhone(contactPhone);
		
		const isComplete = !!(selectedPetId && roomType && checkInDate && checkOutDate && isContactNameValid && isPhoneValid && agreementChecked);
		
		// 更新表单完整性状态
		if (this.data.isFormComplete !== isComplete) {
			this.setData({
				isFormComplete: isComplete
			});
		}
		
		return isComplete;
	},

	/**
	 * 立即支付/充值
	 */
	async confirmBooking() {
		if (!this.checkFormComplete()) {
			wx.showToast({
				title: '请完善预约信息',
				icon: 'none'
			});
			return;
		}

		// 选中的宠物
		const selectedPet = this.data.petList.find(pet => (pet.id === this.data.selectedPetId) || (pet._id === this.data.selectedPetId));
		if (!selectedPet) {
			wx.showToast({ title: '请选择宠物', icon: 'none' });
			return;
		}

		// 门店ID（后端期望为 _id）
		const storeId = this.data.storeInfo._id || this.data.storeInfo.storeId;
		if (!storeId) {
			wx.showToast({ title: '门店信息缺失', icon: 'none' });
			return;
		}

		// 获取当前房型对应的服务ID
		wx.showLoading({ title: '正在创建预约...', mask: true });
		try {
			const serviceId = await this.getServiceIdForCurrentRoom();
			if (!serviceId) {
				wx.hideLoading();
				wx.showToast({ title: '未找到对应服务，请稍后重试', icon: 'none' });
				return;
			}

			// 解析预约开始时间为时间戳（秒）
			const timeStr = this.extractTimeString(this.data.checkInTime); // e.g. '9:00'
			const appointmentTimeSec = this.combineDateTimeToSeconds(this.data.checkInDate, timeStr);
			if (!appointmentTimeSec) {
				wx.hideLoading();
				wx.showToast({ title: '预约时间无效', icon: 'none' });
				return;
			}

			// 构造后端所需预约数据
			const appointmentData = {
				storeId: storeId,
				serviceId: serviceId,
				petIds: [selectedPet._id || selectedPet.id],
				appointmentTime: appointmentTimeSec,
				contactName: this.data.contactName || '',
				contactPhone: this.data.contactPhone || '',
				remarks: this.data.remarks || '',
				totalAmount: this.data.totalPrice * 100, // 转换为分
				totalDays: this.data.totalDays,
				roomType: this.data.roomType,
				roomUnit: this.data.roomUnit // 房间收费单位
			};

			console.log('创建预约数据:', appointmentData);

			const res = await apiService.createAppointment(appointmentData);
			wx.hideLoading();
			if (res.success && res.data && (res.data._id || res.data.appointmentId)) {
				const appointmentId = res.data._id || res.data.appointmentId;
				
				// 预约成功后清除保存的表单数据
				this.clearSavedFormData();
				
				wx.navigateTo({
					url: `/pages/pay/order-detail/index?appointmentId=${appointmentId}`
				});
			} else {
				// 处理API返回的错误信息
				const errorMessage = res.message || '创建预约失败';
				this.handleAppointmentError(errorMessage);
			}
		} catch (error) {
			wx.hideLoading();
			console.error('创建预约异常:', error);
			
			// 处理异常错误信息
			const errorMessage = error.message || '创建预约失败';
			this.handleAppointmentError(errorMessage);
		}
	},

	/**
	 * 处理预约错误信息，根据错误类型显示不同的提示
	 */
	handleAppointmentError(errorMessage) {
		if (errorMessage.includes('PET_CONFLICT:') || errorMessage.includes('该宠物已有预约')) {
			// 宠物已有预约
			const cleanMessage = errorMessage.replace('PET_CONFLICT:', '').trim();
			wx.showToast({ 
				title: cleanMessage || '该宠物已有预约，请选择其他时段', 
				icon: 'none',
				duration: 3000
			});
		} else if (errorMessage.includes('ROOM_FULL:') || errorMessage.includes('该房间已被约满') || errorMessage.includes('该时间段该服务已满') || errorMessage.includes('请选择其他时间或房型')) {
			// 房间已被约满
			const cleanMessage = errorMessage.replace('ROOM_FULL:', '').trim();
			wx.showToast({ 
				title: cleanMessage || '该房间已被约满，请选择其他房型', 
				icon: 'none',
				duration: 3000
			});
		} else {
			wx.showToast({ title: errorMessage, icon: 'none' });
		}
	},

	/**
	 * 日期选择弹窗关闭事件
	 */
	onDatePickerClose() {
		this.setData({
			showDatePicker: false
		});
	},

	/**
	 * 日期选择确认事件
	 */
	onDatePickerConfirm(e) {
		const { startDate, endDate } = e.detail;
		
		// 更新寄养时间数据
		this.setData({
			checkInDate: startDate,
			checkOutDate: endDate,
			showDatePicker: false
		}, () => {
			// 重新计算总天数和价格
			this.calculateTotalDays();
			this.calculatePrice();
			// 检查表单完整性
			this.checkFormComplete();
			// 数据更新后保存表单数据
			this.saveFormData();
		});
		
		console.log('选择的日期范围:', startDate, '到', endDate);
	},

	/**
	 * 宠物选择回调
	 * 从宠物选择页面返回时调用
	 */
	onPetSelected(selectedPet) {
		console.log('选中的宠物:', selectedPet);
		
		// 更新选中的宠物ID
		this.setData({
			selectedPetId: selectedPet.id
		});
		
		// 将select-list页面的数据格式转换为当前页面需要的格式
		const convertedPet = {
			id: selectedPet.id,
			name: selectedPet.nickname, // select-list中使用nickname，当前页使用name
			breed: selectedPet.breed,
			type: selectedPet.gender === 'male' ? 'dog' : 'cat', // 简化类型映射，实际应该有更准确的类型判断
			avatar: selectedPet.avatar
		};
		
		// 更新宠物列表，如果选中的宠物不在列表中则添加
		const { petList } = this.data;
		const existingPetIndex = petList.findIndex(pet => pet.id === selectedPet.id);
		
		if (existingPetIndex === -1) {
			// 宠物不在列表中，添加到列表
			const newPetList = [...petList, convertedPet];
			this.setData({
				petList: newPetList
			}, () => {
				this.checkFormComplete();
			});
		} else {
			// 宠物已存在，更新数据
			const newPetList = [...petList];
			newPetList[existingPetIndex] = convertedPet;
			this.setData({
				petList: newPetList
			}, () => {
				this.checkFormComplete();
			});
		}
		
		wx.showToast({
			title: '宠物选择成功',
			icon: 'success'
		});
	},

	/**
	 * 格式化日期显示
	 */
	formatDateDisplay(dateStr) {
		if (!dateStr) return '';
		const date = new Date(dateStr);
		const month = date.getMonth() + 1;
		const day = date.getDate();
		return `${month}-${day}`;
	},

	/**
	 * 生命周期函数--监听页面初次渲染完成
	 */
	onReady() {

	},


	/**
	 * 生命周期函数--监听页面隐藏
	 */
	onHide() {

	},

	/**
	 * 生命周期函数--监听页面卸载
	 */
	onUnload() {

	},

	/**
	 * 页面相关事件处理函数--监听用户下拉动作
	 */
	onPullDownRefresh() {

	},

	/**
	 * 页面上拉触底事件的处理函数
	 */
	onReachBottom() {

	},

	/**
	 * 页面滚动监听
	 */
	onPageScroll(e) {
		const scrollY = e.scrollTop;
		
		// 计算导航栏背景透明度，滚动距离0-100px内从透明变为不透明
		const maxScrollDistance = 100; // 滚动距离阈值（像素）
		const opacity = Math.min(scrollY / maxScrollDistance, 1);
		
		// 计算文字颜色，透明度达到0.5时开始变黑
		const textColor = opacity >= 0.5 ? '#120E0C' : '#333333';
		
		// 只有在透明度或文字颜色发生变化时才更新
		if (this.data.navbarOpacity !== opacity || this.data.navbarTextColor !== textColor) {
			this.setData({
				scrollY: scrollY,
				navbarOpacity: opacity,
				navbarTextColor: textColor
			});
		}
	},

	/**
	 * 用户点击右上角分享
	 */
	onShareAppMessage() {

	},

	// 将辅助方法移入 Page 对象内部，供 confirmBooking 使用
	async getServiceIdForCurrentRoom() {
		const storeId = this.data.storeInfo._id || this.data.storeInfo.storeId;
		const roomType = this.data.roomType;
		try {
			const res = await apiService.getStoreServices(storeId);
			if (res.success && Array.isArray(res.data)) {
				console.log('查找服务 - roomType:', roomType);
				console.log('当前门店ID:', storeId);
				console.log('可用服务列表:', res.data.map(s => ({ name: s.name, serviceType: s.serviceType, storeIds: s.storeIds })));
				
				// 根据房型映射到对应的serviceType
				const roomTypeToServiceType = {
					'小单间': 'foster',
					'中单间': 'foster', 
					'大单间': 'foster',
					'临时小': 'foster_temp',
					'临时中': 'foster_temp',
					'临时大': 'foster_temp'
				};
				const targetServiceType = roomTypeToServiceType[roomType] || 'foster';
				
				// 先根据serviceType找到对应服务，再检查当前门店是否在该服务的storeIds中
				const target = res.data.find(svc => {
					// 检查serviceType匹配
					if (svc.serviceType !== targetServiceType) {
						return false;
					}
					// 检查当前门店是否在该服务的storeIds数组中
					if (Array.isArray(svc.storeIds)) {
						return svc.storeIds.includes(storeId);
					}
					return false;
				});
				
				console.log('目标serviceType:', targetServiceType);
				console.log('找到的服务:', target);
				return target ? (target._id || target.serviceId || target.id) : null;
			}
			return null;
		} catch (e) {
			console.warn('获取服务ID失败:', e);
			return null;
		}
	},
	extractTimeString(checkInTime) {
		if (!checkInTime) return '';
		// 输入可能为 '9:00入住' 或 '18:00结束'，提取 "HH:mm"
		const match = String(checkInTime).match(/(\d{1,2}:\d{2})/);
		return match ? match[1] : '';
	},
	combineDateTimeToSeconds(dateStr, timeStr) {
		if (!dateStr || !timeStr) return 0;
		// 兼容各种日期格式，拼接后构造 Date
		const [h, m] = timeStr.split(':').map(n => parseInt(n, 10));
		const d = new Date(dateStr);
		if (Number.isNaN(d.getTime())) return 0;
		d.setHours(h, m, 0, 0);
		return Math.floor(d.getTime() / 1000);
	},
	/**
	 * 保存表单数据到本地存储
	 */
	saveFormData() {
		const formData = {
			selectedPetId: this.data.selectedPetId,
			roomType: this.data.roomType,
			checkInDate: this.data.checkInDate,
			checkInTime: this.data.checkInTime,
			checkOutDate: this.data.checkOutDate,
			checkOutTime: this.data.checkOutTime,
			contactName: this.data.contactName,
			contactPhone: this.data.contactPhone,
			remarks: this.data.remarks,
			agreementChecked: this.data.agreementChecked,
			pricePerDay: this.data.pricePerDay,
			storeInfo: this.data.storeInfo,
			timestamp: Date.now() // 添加时间戳，用于判断数据新鲜度
		};
		
		try {
			wx.setStorageSync('foster_care_form_data', formData);
			console.log('表单数据已保存到本地存储:', formData);
		} catch (error) {
			console.error('保存表单数据失败:', error);
		}
	},

	/**
	 * 从本地存储恢复表单数据
	 * @param {boolean} preserveRoomType 是否保留当前房型（如果已有新房型数据，不恢复旧的房型）
	 */
	restoreFormData(preserveRoomType = true) {
		try {
			const savedData = wx.getStorageSync('foster_care_form_data');
			if (!savedData) {
				console.log('没有找到保存的表单数据');
				return;
			}
			
			// 检查数据新鲜度（24小时内有效）
			const maxAge = 24 * 60 * 60 * 1000; // 24小时
			if (savedData.timestamp && (Date.now() - savedData.timestamp > maxAge)) {
				console.log('保存的表单数据已过期，清除数据');
				wx.removeStorageSync('foster_care_form_data');
				return;
			}
			
			console.log('恢复保存的表单数据:', savedData);
			
			// 恢复表单数据
			const updateData = {};
			
			// 恢复基本表单字段
			if (savedData.selectedPetId) updateData.selectedPetId = savedData.selectedPetId;
			
			// 房型处理：如果preserveRoomType为true且当前已有房型，则保留当前房型，否则恢复缓存的房型
			const currentRoomType = this.data.roomType;
			if (!preserveRoomType || !currentRoomType || currentRoomType === '大单间') {
				if (savedData.roomType) updateData.roomType = savedData.roomType;
				if (savedData.pricePerDay) updateData.pricePerDay = savedData.pricePerDay;
				if (savedData.roomUnit) updateData.roomUnit = savedData.roomUnit;
			}
			
			// 恢复时间和联系人信息（这些应该总是恢复）
			if (savedData.checkInDate) updateData.checkInDate = savedData.checkInDate;
			if (savedData.checkInTime) updateData.checkInTime = savedData.checkInTime;
			if (savedData.checkOutDate) updateData.checkOutDate = savedData.checkOutDate;
			if (savedData.checkOutTime) updateData.checkOutTime = savedData.checkOutTime;
			if (savedData.contactName) updateData.contactName = savedData.contactName;
			if (savedData.contactPhone) updateData.contactPhone = savedData.contactPhone;
			if (savedData.remarks) updateData.remarks = savedData.remarks;
			if (typeof savedData.agreementChecked === 'boolean') updateData.agreementChecked = savedData.agreementChecked;
			if (savedData.storeInfo) updateData.storeInfo = savedData.storeInfo;
			
			// 批量更新数据
			if (Object.keys(updateData).length > 0) {
				this.setData(updateData, () => {
					// 数据恢复后重新计算相关值
					this.calculateTotalDays();
					this.calculatePrice();
					this.checkFormComplete();
					console.log('表单数据恢复完成', updateData);
				});
			}
			
		} catch (error) {
			console.error('恢复表单数据失败:', error);
		}
	},

	/**
	 * 清除保存的表单数据
	 */
	clearSavedFormData() {
		try {
			wx.removeStorageSync('foster_care_form_data');
			console.log('已清除保存的表单数据');
		} catch (error) {
			console.error('清除表单数据失败:', error);
		}
	},

	// 页面显示时同步服务价格信息
	// 从门店服务中获取房型对应的价格
	async updateServicePricingFromStoreServices() {
		const storeId = this.data.storeInfo._id || this.data.storeInfo.storeId;
		const roomType = this.data.roomType;
		if (!storeId || !roomType) return;
		
		try {
			// 优先从门店的寄养房间列表获取价格（更准确）
			const roomsRes = await apiService.getStoreFosterRooms(storeId);
			if (roomsRes.success && Array.isArray(roomsRes.data)) {
				console.log('获取到的房间列表:', roomsRes.data);
				console.log('当前需要匹配的房型:', roomType);
				
				// 查找匹配的房型 - 使用更严格的匹配逻辑
				// 优先级：1. 精确匹配 2. 完全包含匹配（避免部分匹配导致误判）
				let matchedRoom = null;
				
				// 第一步：精确匹配（去掉前后空格，大小写不敏感）
				matchedRoom = roomsRes.data.find(room => {
					const roomName = (room.roomName || room.name || '').trim();
					const targetRoomType = roomType.trim();
					return roomName === targetRoomType || roomName.toLowerCase() === targetRoomType.toLowerCase();
				});
				
				// 第二步：如果精确匹配失败，尝试去除常见后缀后精确匹配
				if (!matchedRoom) {
					const normalizeName = (name) => {
						// 去除常见的后缀：间、单间、寄养间等
						return name.replace(/[间单寄养\s]/g, '').trim();
					};
					
					matchedRoom = roomsRes.data.find(room => {
						const roomName = (room.roomName || room.name || '').trim();
						const targetRoomType = roomType.trim();
						
						const normalizedRoomName = normalizeName(roomName);
						const normalizedRoomType = normalizeName(targetRoomType);
						
						// 规范化后精确匹配
						if (normalizedRoomName === normalizedRoomType && normalizedRoomName.length > 0) {
							return true;
						}
						
						return false;
					});
				}
				
				// 第三步：如果还是失败，尝试包含匹配，但要确保核心字匹配（避免"中"匹配"大"）
				if (!matchedRoom) {
					// 提取核心字（小/中/大）
					const extractSize = (name) => {
						if (name.includes('大') || name.includes('large')) return 'large';
						if (name.includes('中') || name.includes('medium')) return 'medium';
						if (name.includes('小') || name.includes('small')) return 'small';
						return '';
					};
					
					const targetSize = extractSize(roomType);
					
					matchedRoom = roomsRes.data.find(room => {
						const roomName = (room.roomName || room.name || '').trim();
						const targetRoomType = roomType.trim();
						
						// 如果核心字不匹配，直接返回false（避免"中寄养间"匹配"大寄养间"）
						const roomSize = extractSize(roomName);
						if (targetSize && roomSize && targetSize !== roomSize) {
							return false;
						}
						
						// 确保包含匹配且核心字一致
						if (roomName.includes(targetRoomType) || targetRoomType.includes(roomName)) {
							return true;
						}
						
						return false;
					});
				}
				
				if (matchedRoom && matchedRoom.price) {
					// 更新价格（价格单位为分，需要转换为元）
					const pricePerDay = typeof matchedRoom.price === 'number' ? (matchedRoom.price / 100) : Number(matchedRoom.price);
					const roomUnit = matchedRoom.unit || '天';
					const matchedRoomName = matchedRoom.roomName || matchedRoom.name || '';
					
					console.log('从房间数据更新价格:', { 
						当前房型: roomType, 
						匹配到的房间: matchedRoomName,
						pricePerDay, 
						roomUnit 
					});
					
					// 如果匹配到的房间名称与当前房型不一致，输出警告
					if (matchedRoomName !== roomType) {
						console.warn('⚠️ 房型匹配不一致！', {
							用户选择的房型: roomType,
							匹配到的房间: matchedRoomName
						});
					}
					
					this.setData({ 
						pricePerDay, 
						roomUnit 
					}, () => {
						// 价格更新后重新计算总价
						this.calculatePrice();
						// 保存到缓存
						this.saveFormData();
					});
					return;
				} else {
					console.warn('未找到匹配的房间，当前房型:', roomType, '房间列表:', roomsRes.data.map(r => r.roomName || r.name));
				}
			}
			
			// 如果房间数据中没有找到，尝试从服务列表中获取
			const res = await apiService.getStoreServices(storeId);
			if (res.success && Array.isArray(res.data)) {
				// 根据房型映射到对应的serviceType
				const roomTypeToServiceType = {
					'小单间': 'foster',
					'中单间': 'foster', 
					'大单间': 'foster',
					'临时小': 'foster_temp',
					'临时中': 'foster_temp',
					'临时大': 'foster_temp'
				};
				const targetServiceType = roomTypeToServiceType[roomType] || 'foster';
				
				// 先根据serviceType找到对应服务，再检查当前门店是否在该服务的storeIds中
				const svc = res.data.find(s => {
					// 检查serviceType匹配
					if (s.serviceType !== targetServiceType) {
						return false;
					}
					// 检查当前门店是否在该服务的storeIds数组中
					if (Array.isArray(s.storeIds)) {
						return s.storeIds.includes(storeId);
					}
					return false;
				});
				
				if (svc && svc.price && svc.price > 0) {
					const pricePerDay = typeof svc.price === 'number' ? (svc.price / 100) : Number(svc.price);
					const unit = svc.unit || this.data.roomUnit || '天';
					this.setData({ pricePerDay, roomUnit: unit }, () => {
						// 价格更新后重新计算总价
						this.calculatePrice();
						// 保存到缓存
						this.saveFormData();
					});
				}
			}
		} catch (e) {
			console.warn('同步服务价格失败:', e);
		}
	}
})
